﻿// -------------------------------------------------------------------------
//    @FileName         :    TestNFLogFormatValidation.h
//    @Author           :    gaoyi
//    @Date             :    2025-01-10
//    @Email            :    445267987@qq.com
//    @Module           :    TestNFLogFormatValidation
//
// -------------------------------------------------------------------------

/**
 * @file TestNFLogFormatValidation.h
 * @brief NFLogMgr C 格式字符串验证单元测试
 * 
 * 此文件提供了对 NFLogMgr 中 C 格式字符串编译期验证功能的完整单元测试，包括：
 * - 基础格式说明符测试
 * - 长度修饰符测试（单字符和双字符）
 * - 长度修饰符与格式说明符兼容性测试
 * - 标志冲突检测测试
 * - 宽度和精度测试
 * - MSVC 平台扩展测试
 * - POSIX 扩展测试
 * - 复杂格式组合测试
 * - 边界条件和错误格式测试
 */

#pragma once

#include <gtest/gtest.h>
#include "NFComm/NFPluginModule/NFLogMgr.h"
#include <string>

/**
 * @brief NFLogMgr 格式验证测试类
 * 
 * 继承自Google Test的测试框架，提供C格式字符串验证的完整测试。
 * 所有测试都使用 constexpr 在编译期进行，确保零运行时开销。
 */
class NFLogFormatValidationTest : public ::testing::Test
{
protected:
    /**
     * @brief 测试用例开始前的初始化
     */
    void SetUp() override
    {
        // 初始化测试环境（如果需要）
    }

    /**
     * @brief 测试用例结束后的清理
     */
    void TearDown() override
    {
        // 清理测试环境（如果需要）
    }
};

// ==========================================================================
// 基础格式说明符测试
// ==========================================================================

/**
 * @brief 测试基本的整数格式说明符
 * 
 * 测试 d, i, u, o, x, X 等整数格式说明符
 */
TEST_F(NFLogFormatValidationTest, BasicIntegerFormatTest)
{
    // 有符号十进制整数
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%d"), "基础 %d 格式应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%i"), "基础 %i 格式应该合法");

    // 无符号整数
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%u"), "基础 %u 格式应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%o"), "基础 %o 格式应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%x"), "基础 %x 格式应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%X"), "基础 %X 格式应该合法");

    // 多个格式说明符
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("Value: %d, Hex: %x"), "多个整数格式应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%d %i %u %o %x %X"), "所有整数格式应该合法");

    SUCCEED() << "所有基础整数格式测试通过";
}

/**
 * @brief 测试浮点格式说明符
 *
 * 测试 f, F, e, E, g, G, a, A 等浮点格式说明符
 */
TEST_F(NFLogFormatValidationTest, FloatFormatTest)
{
    // 基础浮点格式
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%f"), "基础 %f 格式应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%F"), "基础 %F 格式应该合法");

    // 科学计数法
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%e"), "科学计数法 %e 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%E"), "科学计数法 %E 应该合法");

    // 自动格式选择
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%g"), "自动格式 %g 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%G"), "自动格式 %G 应该合法");

    // C99 十六进制浮点
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%a"), "十六进制浮点 %a 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%A"), "十六进制浮点 %A 应该合法");

    // 混合格式
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("PI: %f, E: %e"), "混合浮点格式应该合法");

    SUCCEED() << "所有浮点格式测试通过";
}

/**
 * @brief 测试字符和字符串格式说明符
 */
TEST_F(NFLogFormatValidationTest, CharStringFormatTest)
{
    // 字符格式
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%c"), "字符格式 %c 应该合法");

    // 字符串格式
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%s"), "字符串格式 %s 应该合法");

    // 混合使用
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("Char: %c, String: %s"), "字符和字符串混合应该合法");

    SUCCEED() << "字符和字符串格式测试通过";
}

/**
 * @brief 测试指针和特殊格式说明符
 */
TEST_F(NFLogFormatValidationTest, PointerSpecialFormatTest)
{
    // 指针格式
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%p"), "指针格式 %p 应该合法");

    // 转义百分号
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%%"), "转义 %% 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("100%%"), "百分比显示应该合法");

    // 写入字符数（虽然不推荐使用）
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%n"), "格式 %n 应该合法");

    // POSIX 扩展：strerror(errno)
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%m"), "POSIX %m 格式应该合法");

    SUCCEED() << "指针和特殊格式测试通过";
}

// ==========================================================================
// 长度修饰符测试
// ==========================================================================

/**
 * @brief 测试单字符长度修饰符
 *
 * 测试 h, l, L, j, z, t, q 等单字符长度修饰符
 */
TEST_F(NFLogFormatValidationTest, SingleLengthModifierTest)
{
    // h (short)
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%hd"), "short 格式 %hd 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%hu"), "unsigned short 格式 %hu 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%hx"), "short hex 格式 %hx 应该合法");

    // l (long)
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%ld"), "long 格式 %ld 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%lu"), "unsigned long 格式 %lu 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%lf"), "long double 格式 %lf 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%lc"), "wchar_t 格式 %lc 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%ls"), "wchar_t* 格式 %ls 应该合法");

    // L (long double)
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%Lf"), "long double %Lf 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%Le"), "long double %Le 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%Lg"), "long double %Lg 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%La"), "long double %La 应该合法");

    // j (intmax_t)
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%jd"), "intmax_t 格式 %jd 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%ju"), "uintmax_t 格式 %ju 应该合法");

    // z (size_t)
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%zd"), "size_t 格式 %zd 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%zu"), "size_t 格式 %zu 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%zx"), "size_t hex 格式 %zx 应该合法");

    // t (ptrdiff_t)
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%td"), "ptrdiff_t 格式 %td 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%tu"), "ptrdiff_t 格式 %tu 应该合法");

    SUCCEED() << "单字符长度修饰符测试通过";
}

/**
 * @brief 测试双字符长度修饰符
 *
 * 测试 hh, ll 等双字符长度修饰符
 */
TEST_F(NFLogFormatValidationTest, DoubleLengthModifierTest)
{
    // hh (char)
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%hhd"), "char 格式 %hhd 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%hhu"), "unsigned char 格式 %hhu 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%hhx"), "unsigned char hex 格式 %hhx 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%hho"), "unsigned char oct 格式 %hho 应该合法");

    // ll (long long)
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%lld"), "long long 格式 %lld 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%llu"), "unsigned long long 格式 %llu 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%llx"), "long long hex 格式 %llx 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%lli"), "long long 格式 %lli 应该合法");

    // 混合使用
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("Char: %hhd, LongLong: %lld"), "混合双字符修饰符应该合法");

    SUCCEED() << "双字符长度修饰符测试通过";
}

// ==========================================================================
// 长度修饰符兼容性测试
// ==========================================================================

/**
 * @brief 测试长度修饰符与格式说明符的兼容性
 *
 * 验证不兼容的组合会被正确拒绝
 */
TEST_F(NFLogFormatValidationTest, LengthSpecifierCompatibilityTest)
{
    // ===== 应该被拒绝的组合 =====

    // L 只能用于浮点，不能用于整数
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%Ld"), "L不能用于整数 %Ld 应该被拒绝");
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%Li"), "L不能用于整数 %Li 应该被拒绝");
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%Lu"), "L不能用于整数 %Lu 应该被拒绝");
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%Lx"), "L不能用于整数 %Lx 应该被拒绝");

    // ll 不能用于浮点
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%llf"), "ll不能用于浮点 %llf 应该被拒绝");
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%lle"), "ll不能用于浮点 %lle 应该被拒绝");
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%llg"), "ll不能用于浮点 %llg 应该被拒绝");

    // hh 不能用于浮点
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%hhf"), "hh不能用于浮点 %hhf 应该被拒绝");

    // h 不能用于字符（c可以用l，但不能用h）
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%hc"), "h不能用于字符 %hc 应该被拒绝");
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%hs"), "h不能用于字符串 %hs 应该被拒绝");

    // j, z, t 不能用于浮点
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%jf"), "j不能用于浮点 %jf 应该被拒绝");
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%zf"), "z不能用于浮点 %zf 应该被拒绝");
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%tf"), "t不能用于浮点 %tf 应该被拒绝");

    // ===== 应该被接受的组合 =====

    // L 用于浮点是合法的
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%Lf"), "L用于浮点 %Lf 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%LF"), "L用于浮点 %LF 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%Le"), "L用于浮点 %Le 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%Lg"), "L用于浮点 %Lg 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%La"), "L用于浮点 %La 应该合法");

    // ll 用于整数是合法的
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%lld"), "ll用于整数 %lld 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%llu"), "ll用于整数 %llu 应该合法");

    // l 用于浮点是合法的（对double没有实际效果，但语法合法）
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%lf"), "l用于浮点 %lf 应该合法");

    SUCCEED() << "长度修饰符兼容性测试通过";
}

// ==========================================================================
// 标志测试
// ==========================================================================

/**
 * @brief 测试单个标志
 */
TEST_F(NFLogFormatValidationTest, SingleFlagTest)
{
    // 左对齐
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%-d"), "左对齐 %-d 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%-10s"), "左对齐字符串 %-10s 应该合法");

    // 显示正号
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%+d"), "显示正号 %+d 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%+f"), "显示正号 %+f 应该合法");

    // 正数前加空格
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("% d"), "空格标志 % d 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("% f"), "空格标志 % f 应该合法");

    // 备用格式
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%#x"), "备用格式 %#x 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%#o"), "备用格式 %#o 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%#f"), "备用格式 %#f 应该合法");

    // 零填充
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%0d"), "零填充 %0d 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%08d"), "零填充 %08d 应该合法");

    // 千位分隔符（POSIX扩展）
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%'d"), "千位分隔符 %'d 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%'f"), "千位分隔符 %'f 应该合法");

    SUCCEED() << "单个标志测试通过";
}

/**
 * @brief 测试标志组合
 */
TEST_F(NFLogFormatValidationTest, FlagCombinationTest)
{
    // 合法的标志组合
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%-+10d"), "组合 %-+10d 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%+010.5f"), "组合 %+010.5f 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%#010x"), "组合 %#010x 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%'10d"), "组合 %'10d 应该合法");

    SUCCEED() << "标志组合测试通过";
}

/**
 * @brief 测试标志冲突检测
 */
TEST_F(NFLogFormatValidationTest, FlagConflictTest)
{
    // '-' 和 '0' 冲突
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%-0d"), "冲突 %-0d 应该被拒绝");
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%0-10d"), "冲突 %0-10d 应该被拒绝");

    // '+' 和 ' ' 冲突
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%+ d"), "冲突 %+ d 应该被拒绝");
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("% +d"), "冲突 % +d 应该被拒绝");

    // 标志不能重复
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%--d"), "重复 %--d 应该被拒绝");
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%++d"), "重复 %++d 应该被拒绝");
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%##x"), "重复 %##x 应该被拒绝");
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%00d"), "重复 %00d 应该被拒绝");

    SUCCEED() << "标志冲突测试通过";
}

// ==========================================================================
// 宽度和精度测试
// ==========================================================================

/**
 * @brief 测试固定宽度
 */
TEST_F(NFLogFormatValidationTest, WidthTest)
{
    // 单位数宽度
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%5d"), "宽度5应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%1s"), "宽度1应该合法");

    // 多位数宽度
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%10d"), "宽度10应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%100s"), "宽度100应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%1000d"), "宽度1000应该合法");

    // 动态宽度
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%*d"), "动态宽度 %*d 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%*s"), "动态宽度 %*s 应该合法");

    // 宽度与标志组合
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%-10d"), "左对齐宽度 %-10d 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%+10d"), "显示正号宽度 %+10d 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%010d"), "零填充宽度 %010d 应该合法");

    SUCCEED() << "宽度测试通过";
}

/**
 * @brief 测试精度
 */
TEST_F(NFLogFormatValidationTest, PrecisionTest)
{
    // 固定精度
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%.5f"), "精度5应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%.10f"), "精度10应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%.100f"), "精度100应该合法");

    // 精度为0
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%.0f"), "精度0应该合法");

    // 动态精度
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%.*f"), "动态精度 %.*f 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%.*s"), "动态精度 %.*s 应该合法");

    // 宽度和精度组合
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%10.5f"), "宽度和精度 %10.5f 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%100.50f"), "宽度和精度 %100.50f 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%*.*f"), "动态宽度和精度 %*.*f 应该合法");

    // 字符串精度（限制输出长度）
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%.10s"), "字符串精度 %.10s 应该合法");

    SUCCEED() << "精度测试通过";
}

// ==========================================================================
// MSVC 平台扩展测试
// ==========================================================================

/**
 * @brief 测试 MSVC 平台的 I 前缀扩展
 */
TEST_F(NFLogFormatValidationTest, MSVCExtensionTest)
{
#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__)
    // I32 - 32位整数
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%I32d"), "MSVC I32d 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%I32u"), "MSVC I32u 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%I32x"), "MSVC I32x 应该合法");

    // I64 - 64位整数
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%I64d"), "MSVC I64d 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%I64u"), "MSVC I64u 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%I64x"), "MSVC I64x 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%I64X"), "MSVC I64X 应该合法");

    // I - 平台相关
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%Id"), "MSVC Id 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%Iu"), "MSVC Iu 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%Ix"), "MSVC Ix 应该合法");

    // 与宽度、精度、标志组合
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%10I64d"), "MSVC 宽度 %10I64d 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%+I32d"), "MSVC 标志 %+I32d 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%#I64x"), "MSVC 备用格式 %#I64x 应该合法");

    SUCCEED() << "MSVC 扩展测试通过";
#else
    // 非MSVC平台也应该能识别这些格式（为了跨平台兼容性）
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%I32d"), "I32d 应该被识别"); static_assert(nf_safe_format_detail::validate_format_string_enhanced("%I64d"), "I64d 应该被识别"); SUCCEED() << "MSVC 扩展测试跳过（非MSVC平台）";
#endif
}

// ==========================================================================
// 复杂格式组合测试
// ==========================================================================

/**
 * @brief 测试复杂的格式组合
 */
TEST_F(NFLogFormatValidationTest, ComplexFormatTest)
{
    // 完整的格式：标志+宽度+精度+长度修饰符+说明符
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%-+10.5lld"), "完整格式 %-+10.5lld 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%#010.5f"), "完整格式 %#010.5f 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%+'*.*Lf"), "动态完整格式 %+'*.*Lf 应该合法");

    // 多个复杂格式混合
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("Player %lld: %s (level %-5d, exp %10.2f%%)"), "游戏日志格式应该合法");

    static_assert(nf_safe_format_detail::validate_format_string_enhanced("Time: %02d:%02d:%02d, Value: %+10.5f"), "时间和数值格式应该合法");

    static_assert(nf_safe_format_detail::validate_format_string_enhanced("Hex: %#010llx, Dec: %-15llu, Oct: %#012llo"), "多进制格式应该合法");

    // 包含文本的复杂格式
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("[%s] Player %lld login at %02d:%02d:%02d, IP: %s, Port: %u"), "完整日志格式应该合法");

    SUCCEED() << "复杂格式组合测试通过";
}

// ==========================================================================
// 错误格式测试
// ==========================================================================

/**
 * @brief 测试应该被拒绝的错误格式
 */
TEST_F(NFLogFormatValidationTest, InvalidFormatTest)
{
    // 未闭合的格式说明符
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%"), "未闭合的 % 应该被拒绝");

    // 无效的格式说明符
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%q"), "无效说明符 %q 应该被拒绝");
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%k"), "无效说明符 %k 应该被拒绝");

    // 无效的长度修饰符组合
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%hlld"), "无效组合 %hlld 应该被拒绝");
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced("%lhd"), "无效组合 %lhd 应该被拒绝");

    // 精度格式错误
    // 注意：%.d 在某些实现中可能被接受，这里根据严格的标准应该有数字或*

    SUCCEED() << "错误格式测试通过";
}

// ==========================================================================
// 边界条件测试
// ==========================================================================

/**
 * @brief 测试边界条件和特殊情况
 */
TEST_F(NFLogFormatValidationTest, BoundaryTest)
{
    // 空字符串（技术上没有格式说明符，但不是错误）
    // 注意：validate_format_string_enhanced 对空字符串返回 false
    static_assert(!nf_safe_format_detail::validate_format_string_enhanced(""), "空字符串应该返回 false");

    // 没有格式说明符的普通字符串（不需要验证，但不是错误）
    // 注意：没有 % 的字符串会返回 false（因为没有格式需要验证）

    // 连续的转义百分号
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%%%%"), "连续转义 %%%% 应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("100%% done"), "文本中的 %% 应该合法");

    // 极长的宽度和精度
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%99999d"), "极长宽度应该合法");
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%.99999f"), "极长精度应该合法");

    // 所有标志的组合
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("%-+'#10.5f"), "所有标志组合应该合法");

    SUCCEED() << "边界条件测试通过";
}

// ==========================================================================
// 实际使用场景测试
// ==========================================================================

/**
 * @brief 测试实际游戏日志中常见的格式
 */
TEST_F(NFLogFormatValidationTest, RealWorldUsageTest)
{
    // 玩家相关日志
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("Player %lld login success, name: %s, level: %d"), "玩家登录日志应该合法");

    // 错误日志
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("Error code: %d, message: %s, time: %lld"), "错误日志应该合法");

    // 性能日志
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("Function %s took %.2f ms to execute"), "性能日志应该合法");

    // 网络日志
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("Received packet: type=%u, size=%zu, from=%s:%u"), "网络日志应该合法");

    // 资源日志
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("Memory usage: %zu KB, CPU: %.1f%%, Threads: %d"), "资源日志应该合法");

    // 十六进制调试日志
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("Pointer: %p, Value: %#x, Flags: %#08x"), "十六进制调试日志应该合法");

    // 带时间戳的日志
    static_assert(nf_safe_format_detail::validate_format_string_enhanced("[%04d-%02d-%02d %02d:%02d:%02d] %s"), "时间戳日志应该合法");

    SUCCEED() << "实际使用场景测试通过";
}

// ==========================================================================
// 编译期与运行时一致性测试
// ==========================================================================

/**
 * @brief 测试编译期验证与运行时行为的一致性
 */
TEST_F(NFLogFormatValidationTest, CompileTimeRuntimeConsistencyTest)
{
    // 这些格式在编译期应该通过，运行时也应该能正常工作

    // 测试整数格式
    {
        static_assert(nf_safe_format_detail::validate_format_string_enhanced("%d"), "编译期检查通过");
        std::string result = NFSprintfFunc("%d", 42);
        EXPECT_FALSE(result.empty());
        EXPECT_EQ(result, "42");
    }

    // 测试浮点格式
    {
        static_assert(nf_safe_format_detail::validate_format_string_enhanced("%.2f"), "编译期检查通过");
        std::string result = NFSprintfFunc("%.2f", 3.14159);
        EXPECT_FALSE(result.empty());
        EXPECT_EQ(result, "3.14");
    }

    // 测试字符串格式
    {
        static_assert(nf_safe_format_detail::validate_format_string_enhanced("%s"), "编译期检查通过");
        std::string result = NFSprintfFunc("%s", "test");
        EXPECT_FALSE(result.empty());
        EXPECT_EQ(result, "test");
    }

    // 测试长度修饰符
    {
        static_assert(nf_safe_format_detail::validate_format_string_enhanced("%lld"), "编译期检查通过");
        std::string result = NFSprintfFunc("%lld", 123456789012345LL);
        EXPECT_FALSE(result.empty());
    }

    // 测试复杂格式
    {
        static_assert(nf_safe_format_detail::validate_format_string_enhanced("Player %lld: %s (level %d)"), "编译期检查通过");
        std::string result = NFSprintfFunc("Player %lld: %s (level %d)", 123456LL, "TestPlayer", 99);
        EXPECT_FALSE(result.empty());
        EXPECT_TRUE(result.find("Player 123456") != std::string::npos);
        EXPECT_TRUE(result.find("TestPlayer") != std::string::npos);
        EXPECT_TRUE(result.find("level 99") != std::string::npos);
    }

    SUCCEED() << "编译期与运行时一致性测试通过";
}

// ==========================================================================
// Fmt 格式字符串验证测试
// ==========================================================================

/**
 * @brief 测试 fmt 风格格式字符串的扫描和验证
 *
 * 测试改进后的 scan_format 函数对各种 fmt 格式的支持
 */
TEST_F(NFLogFormatValidationTest, FmtFormatScanTest)
{
    // ===== 基础占位符测试 =====

    // 简单的空占位符
    static_assert(nf_safe_format_detail::scan_format("Hello {}", 0), "简单占位符 {} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("Value: {}, {}", 0), "多个占位符应该被识别");

    // 显式索引
    static_assert(nf_safe_format_detail::scan_format("Item {0}", 0), "显式索引 {0} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{0} and {1}", 0), "多个显式索引应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{10}", 0), "多位数字索引 {10} 应该被识别");

    // ===== 格式规格测试 =====

    // 基础类型格式
    static_assert(nf_safe_format_detail::scan_format("{:d}", 0), "整数格式 {:d} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{:f}", 0), "浮点格式 {:f} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{:s}", 0), "字符串格式 {:s} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{:x}", 0), "十六进制格式 {:x} 应该被识别");

    // 精度格式
    static_assert(nf_safe_format_detail::scan_format("{:.2f}", 0), "精度格式 {:.2f} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{:.5}", 0), "精度格式 {:.5} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{:.10e}", 0), "科学计数法精度 {:.10e} 应该被识别");

    // 宽度格式
    static_assert(nf_safe_format_detail::scan_format("{:10}", 0), "宽度格式 {:10} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{:10d}", 0), "宽度+类型 {:10d} 应该被识别");

    // 宽度+精度组合
    static_assert(nf_safe_format_detail::scan_format("{:10.5f}", 0), "宽度+精度 {:10.5f} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{:20.10e}", 0), "宽度+精度 {:20.10e} 应该被识别");

    // ===== 对齐和填充测试 =====

    // 对齐
    static_assert(nf_safe_format_detail::scan_format("{:<10}", 0), "左对齐 {:<10} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{:>10}", 0), "右对齐 {:>10} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{:^10}", 0), "居中对齐 {:^10} 应该被识别");

    // 填充+对齐
    static_assert(nf_safe_format_detail::scan_format("{:*<10}", 0), "填充+对齐 {:*<10} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{:0>10}", 0), "零填充+对齐 {:0>10} 应该被识别");

    // ===== 符号和标志测试 =====

    // 符号
    static_assert(nf_safe_format_detail::scan_format("{:+d}", 0), "显示正号 {:+d} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{:-d}", 0), "仅负号 {:-d} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{: d}", 0), "空格符号 {: d} 应该被识别");

    // 标志
    static_assert(nf_safe_format_detail::scan_format("{:#x}", 0), "备用格式 {:#x} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{:#o}", 0), "备用格式 {:#o} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{:0d}", 0), "零填充 {:0d} 应该被识别");

    // 千位分隔符
    static_assert(nf_safe_format_detail::scan_format("{:,d}", 0), "千位分隔符 {:,d} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{:_d}", 0), "下划线分隔符 {:_d} 应该被识别");

    // ===== 索引+格式规格组合测试 =====

    static_assert(nf_safe_format_detail::scan_format("{0:d}", 0), "索引+类型 {0:d} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{0:.2f}", 0), "索引+精度 {0:.2f} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{1:>10}", 0), "索引+对齐 {1:>10} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{2:+10.5f}", 0), "索引+完整格式 {2:+10.5f} 应该被识别");

    // ===== 转义测试 =====

    // 转义的大括号不应该被识别为占位符
    static_assert(!nf_safe_format_detail::scan_format("{{not a placeholder}}", 0), "转义的大括号 {{}} 不应该被识别为占位符");

    // 但包含转义和真实占位符的混合应该被识别
    static_assert(nf_safe_format_detail::scan_format("Price: {{100}} = {}", 0), "混合转义和占位符应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{{}} {0} {{}}", 0), "混合格式应该被识别");

    // ===== 复杂格式测试 =====

    // 完整的复杂格式
    static_assert(nf_safe_format_detail::scan_format("{:+#10.5f}", 0), "复杂格式 {:+#10.5f} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{:*^20.10e}", 0), "复杂格式 {:*^20.10e} 应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{0:+#020.5f}", 0), "索引+复杂格式 {0:+#020.5f} 应该被识别");

    // 多个不同格式的占位符
    static_assert(nf_safe_format_detail::scan_format("Player {0}: {1:s} (level {2:d}, exp {3:.2f}%)", 0), "多个复杂占位符应该被识别");

    // ===== 实际使用场景测试 =====

    // 游戏日志格式
    static_assert(nf_safe_format_detail::scan_format("Player {} login at {}", 0), "游戏日志格式应该被识别");
    static_assert(nf_safe_format_detail::scan_format("Level up: {} -> {} (+{:.1f}%)", 0), "升级日志应该被识别");
    static_assert(nf_safe_format_detail::scan_format("Position: ({:.2f}, {:.2f}, {:.2f})", 0), "坐标日志应该被识别");

    // 格式化表格
    static_assert(nf_safe_format_detail::scan_format("{:<20} {:>10} {:>10}", 0), "表格格式应该被识别");
    static_assert(nf_safe_format_detail::scan_format("{:^30}", 0), "标题居中格式应该被识别");

    // ===== 边界条件测试 =====

    // 空字符串
    static_assert(!nf_safe_format_detail::scan_format("", 0), "空字符串不应该被识别");

    // 没有占位符的字符串
    static_assert(!nf_safe_format_detail::scan_format("No placeholders here", 0), "没有占位符的字符串不应该被识别");

    // 只有转义的字符串
    static_assert(!nf_safe_format_detail::scan_format("{{}}{{}}{{", 0), "只有转义的字符串不应该被识别");

    SUCCEED() << "Fmt 格式字符串扫描测试通过";
}

/**
 * @brief 测试 fmt 格式字符串验证的辅助函数
 */
TEST_F(NFLogFormatValidationTest, FmtFormatHelperTest)
{
    // 测试 is_fmt_spec_char 函数
    static_assert(nf_safe_format_detail::is_fmt_spec_char('d'), "d 应该是有效字符");
    static_assert(nf_safe_format_detail::is_fmt_spec_char('f'), "f 应该是有效字符");
    static_assert(nf_safe_format_detail::is_fmt_spec_char('.'), ". 应该是有效字符");
    static_assert(nf_safe_format_detail::is_fmt_spec_char('<'), "< 应该是有效字符");
    static_assert(nf_safe_format_detail::is_fmt_spec_char('+'), "+ 应该是有效字符");
    static_assert(nf_safe_format_detail::is_fmt_spec_char('0'), "0 应该是有效字符");

    // 测试 is_digit_or_dot 函数
    static_assert(nf_safe_format_detail::is_digit_or_dot('0'), "0 应该是数字或点");
    static_assert(nf_safe_format_detail::is_digit_or_dot('5'), "5 应该是数字或点");
    static_assert(nf_safe_format_detail::is_digit_or_dot('.'), ". 应该是数字或点");
    static_assert(!nf_safe_format_detail::is_digit_or_dot('a'), "a 不应该是数字或点");

    SUCCEED() << "Fmt 格式辅助函数测试通过";
}

// ==========================================================================
// 性能测试
// ==========================================================================

/**
 * @brief 验证编译期验证不会影响运行时性能
 */
TEST_F(NFLogFormatValidationTest, PerformanceTest)
{
    // 编译期验证应该零运行时开销
    // 这里只是验证可以正常编译和运行

    const int iterations = 10000;

    auto start = std::chrono::high_resolution_clock::now();

    for (int i = 0; i < iterations; ++i)
    {
        // 使用经过编译期验证的格式
        std::string result = NFSprintfFunc("Value: %d, Float: %.2f", i, i * 0.1);
        // 编译器应该优化掉不需要的代码
    }

    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);

    // 只是确保能正常执行，不做严格的性能断言
    EXPECT_LT(duration.count(), 5000); // 应该在5秒内完成

    SUCCEED() << "性能测试通过 - 执行时间: " << duration.count() << "ms";
}

